2
          
          module BloggerStructs
        
      
        

          2
          
            class Blog < ActionWebService::Struct
        
      
        

          2
          
              member :url,      :string
        
      
        

          2
          
              member :blogid,   :string
        
      
        

          2
          
              member :blogName, :string
        
      
        

          
          
            end
        
      
        

          2
          
            class User < ActionWebService::Struct
        
      
        

          2
          
              member :userid, :string
        
      
        

          2
          
              member :firstname, :string
        
      
        

          2
          
              member :lastname, :string
        
      
        

          2
          
              member :nickname, :string
        
      
        

          2
          
              member :email, :string
        
      
        

          2
          
              member :url, :string
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          2
          
          class BloggerApi < ActionWebService::API::Base
        
      
        

          2
          
            inflect_names false
        
      
        

          
          
          
        
      
        

          2
          
            api_method :deletePost,
        
      
        

          
          
              :expects => [ {:appkey => :string}, {:postid => :int}, {:username => :string}, {:password => :string},
        
      
        

          
          
                            {:publish => :bool} ],
        
      
        

          
          
              :returns => [:bool]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getUserInfo,
        
      
        

          
          
              :expects => [ {:appkey => :string}, {:username => :string}, {:password => :string} ],
        
      
        

          
          
              :returns => [BloggerStructs::User]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getUsersBlogs,
        
      
        

          
          
              :expects => [ {:appkey => :string}, {:username => :string}, {:password => :string} ],
        
      
        

          
          
              :returns => [[BloggerStructs::Blog]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :newPost,
        
      
        

          
          
              :expects => [ {:appkey => :string}, {:blogid => :string}, {:username => :string}, {:password => :string},
        
      
        

          
          
                            {:content => :string}, {:publish => :bool} ],
        
      
        

          
          
              :returns => [:int]
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          2
          
          class BloggerService < TypoWebService
        
      
        

          2
          
            web_service_api BloggerApi
        
      
        

          2
          
            before_invocation :authenticate
        
      
        

          
          
          
        
      
        

          2
          
            def deletePost(appkey, postid, username, password, publish)
        
      
        

          
          
              Article.destroy(postid)
        
      
        

          
          
              true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def getUserInfo(appkey, username, password)
        
      
        

          
          
              BloggerStructs::User.new(
        
      
        

          
          
                :userid => username,
        
      
        

          
          
                :firstname => "",
        
      
        

          
          
                :lastname => "",
        
      
        

          
          
                :nickname => username,
        
      
        

          
          
                :email => "",
        
      
        

          
          
                :url => this_blog.base_url
        
      
        

          
          
              )
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def getUsersBlogs(appkey, username, password)
        
      
        

          
          
              [BloggerStructs::Blog.new(
        
      
        

          
          
                :url      => this_blog.base_url,
        
      
        

          
          
                :blogid   => this_blog.id,
        
      
        

          
          
                :blogName => this_blog.blog_name
        
      
        

          
          
              )]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def newPost(appkey, blogid, username, password, content, publish)
        
      
        

          
          
              title, categories, body = content.match(%r{^<title>(.+?)</title>(?:<category>(.+?)</category>)?(.+)$}mi).captures rescue nil
        
      
        

          
          
          
        
      
        

          
          
              article = Article.new
        
      
        

          
          
              article.body           = body || content || ''
        
      
        

          
          
              article.title          = title || content.split.slice(0..5).join(' ') || ''
        
      
        

          
          
              article.published      = publish
        
      
        

          
          
              article.author         = username
        
      
        

          
          
              article.published_at   = Time.now
        
      
        

          
          
              article.user           = @user
        
      
        

          
          
              article.allow_comments = this_blog.default_allow_comments
        
      
        

          
          
              article.allow_pings    = this_blog.default_allow_pings
        
      
        

          
          
              article.text_filter    = this_blog.text_filter
        
      
        

          
          
              article.save
        
      
        

          
          
          
        
      
        

          
          
              if categories
        
      
        

          
          
                categories.split(",").each do |c|
        
      
        

          
          
                  article.categories << Category.find_by_name(c.strip) rescue nil
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              article.id
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          module MetaWeblogStructs
        
      
        

          2
          
            class Article < ActionWebService::Struct
        
      
        

          2
          
              member :description,        :string
        
      
        

          2
          
              member :title,              :string
        
      
        

          2
          
              member :postid,             :string
        
      
        

          2
          
              member :url,                :string
        
      
        

          2
          
              member :link,               :string
        
      
        

          2
          
              member :permaLink,          :string
        
      
        

          2
          
              member :categories,         [:string]
        
      
        

          2
          
              member :mt_text_more,       :string
        
      
        

          2
          
              member :mt_excerpt,         :string
        
      
        

          2
          
              member :mt_keywords,        :string
        
      
        

          2
          
              member :mt_allow_comments,  :int
        
      
        

          2
          
              member :mt_allow_pings,     :int
        
      
        

          2
          
              member :mt_convert_breaks,  :string
        
      
        

          2
          
              member :mt_tb_ping_urls,    [:string]
        
      
        

          2
          
              member :dateCreated,        :time
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            class MediaObject < ActionWebService::Struct
        
      
        

          2
          
              member :bits, :string
        
      
        

          2
          
              member :name, :string
        
      
        

          2
          
              member :type, :string
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            class Url < ActionWebService::Struct
        
      
        

          2
          
              member :url, :string
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          2
          
          class MetaWeblogApi < ActionWebService::API::Base
        
      
        

          2
          
            inflect_names false
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getCategories,
        
      
        

          
          
              :expects => [ {:blogid => :string}, {:username => :string}, {:password => :string} ],
        
      
        

          
          
              :returns => [[:string]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getPost,
        
      
        

          
          
              :expects => [ {:postid => :string}, {:username => :string}, {:password => :string} ],
        
      
        

          
          
              :returns => [MetaWeblogStructs::Article]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getRecentPosts,
        
      
        

          
          
              :expects => [ {:blogid => :string}, {:username => :string}, {:password => :string}, {:numberOfPosts => :int} ],
        
      
        

          
          
              :returns => [[MetaWeblogStructs::Article]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :deletePost,
        
      
        

          
          
              :expects => [ {:appkey => :string}, {:postid => :string}, {:username => :string}, {:password => :string}, {:publish => :int} ],
        
      
        

          
          
              :returns => [:bool]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :editPost,
        
      
        

          
          
              :expects => [ {:postid => :string}, {:username => :string}, {:password => :string}, {:struct => MetaWeblogStructs::Article}, {:publish => :int} ],
        
      
        

          
          
              :returns => [:bool]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :newPost,
        
      
        

          
          
              :expects => [ {:blogid => :string}, {:username => :string}, {:password => :string}, {:struct => MetaWeblogStructs::Article}, {:publish => :int} ],
        
      
        

          
          
              :returns => [:string]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :newMediaObject,
        
      
        

          
          
              :expects => [ {:blogid => :string}, {:username => :string}, {:password => :string}, {:data => MetaWeblogStructs::MediaObject} ],
        
      
        

          
          
              :returns => [MetaWeblogStructs::Url]
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          2
          
          class MetaWeblogService < TypoWebService
        
      
        

          2
          
            web_service_api MetaWeblogApi
        
      
        

          2
          
            before_invocation :authenticate
        
      
        

          
          
          
        
      
        

          2
          
            def getCategories(blogid, username, password)
        
      
        

          
          
              Category.find(:all).collect { |c| c.name }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def getPost(postid, username, password)
        
      
        

          
          
              article = Article.find(postid)
        
      
        

          
          
          
        
      
        

          
          
              article_dto_from(article)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def getRecentPosts(blogid, username, password, numberOfPosts)
        
      
        

          
          
              Article.find(:all, :order => "created_at DESC", :limit => numberOfPosts).collect{ |c| article_dto_from(c) }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def newPost(blogid, username, password, struct, publish)
        
      
        

          
          
              article = Article.new
        
      
        

          
          
              article.body        = struct['description'] || ''
        
      
        

          
          
              article.title       = struct['title'] || ''
        
      
        

          
          
              article.author      = username
        
      
        

          
          
              article.published_at = struct['dateCreated'].to_time.getlocal rescue Time.now
        
      
        

          
          
              article.published   = publish
        
      
        

          
          
              article.user        = @user
        
      
        

          
          
          
        
      
        

          
          
              # Movable Type API support
        
      
        

          
          
              article.allow_comments = struct['mt_allow_comments']  || this_blog.default_allow_comments
        
      
        

          
          
              article.allow_pings    = struct['mt_allow_pings']     || this_blog.default_allow_pings
        
      
        

          
          
              article.extended       = struct['mt_text_more']       || ''
        
      
        

          
          
              article.excerpt        = struct['mt_excerpt']         || ''
        
      
        

          
          
              article.text_filter    = TextFilter.find_by_name(struct['mt_convert_breaks'] || this_blog.text_filter)
        
      
        

          
          
              article.keywords       = struct['mt_keywords']        || ''
        
      
        

          
          
          
        
      
        

          
          
              if !article.save
        
      
        

          
          
                raise article.errors.full_messages * ", "
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if struct['categories']
        
      
        

          
          
                Category.find(:all).each do |c|
        
      
        

          
          
                  article.categories << c if struct['categories'].include?(c.name)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              article.id.to_s
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def deletePost(appkey, postid, username, password, publish)
        
      
        

          
          
              Article.destroy(postid)
        
      
        

          
          
              true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def editPost(postid, username, password, struct, publish)
        
      
        

          
          
              article = Article.find(postid)
        
      
        

          
          
              article.body        = struct['description'] || ''
        
      
        

          
          
              article.title       = struct['title'] || ''
        
      
        

          
          
              article.published   = publish
        
      
        

          
          
              article.author      = username
        
      
        

          
          
              article.published_at  = struct['dateCreated'].to_time.getlocal unless struct['dateCreated'].blank?
        
      
        

          
          
          
        
      
        

          
          
              # Movable Type API support
        
      
        

          
          
              article.allow_comments = struct['mt_allow_comments'] || this_blog.default_allow_comments
        
      
        

          
          
              article.allow_pings    = struct['mt_allow_pings']    || this_blog.default_allow_pings
        
      
        

          
          
              article.extended       = struct['mt_text_more']      || ''
        
      
        

          
          
              article.excerpt        = struct['mt_excerpt']        || ''
        
      
        

          
          
              article.keywords       = struct['mt_keywords']       || ''
        
      
        

          
          
              article.text_filter    = TextFilter.find_by_name(struct['mt_convert_breaks'] || this_blog.text_filter)
        
      
        

          
          
          
        
      
        

          
          
              if struct['categories']
        
      
        

          
          
                article.categorizations.clear
        
      
        

          
          
                Category.find(:all).each do |c|
        
      
        

          
          
                  article.categories << c if struct['categories'].include?(c.name)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              ::Rails.logger.info(struct['mt_tb_ping_urls'])
        
      
        

          
          
              article.save
        
      
        

          
          
              true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def newMediaObject(blogid, username, password, data)
        
      
        

          
          
              resource = Resource.create(:filename => data['name'], :mime => data['type'], :created_at => Time.now)
        
      
        

          
          
              resource.write_to_disk(data['bits'])
        
      
        

          
          
          
        
      
        

          
          
              MetaWeblogStructs::Url.new("url" => this_blog.file_url(resource.filename))
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def article_dto_from(article)
        
      
        

          
          
              MetaWeblogStructs::Article.new(
        
      
        

          
          
                :description       => article.body,
        
      
        

          
          
                :title             => article.title,
        
      
        

          
          
                :postid            => article.id.to_s,
        
      
        

          
          
                :url               => article.permalink_url,
        
      
        

          
          
                :link              => article.permalink_url,
        
      
        

          
          
                :permaLink         => article.permalink_url,
        
      
        

          
          
                :categories        => article.categories.collect { |c| c.name },
        
      
        

          
          
                :mt_text_more      => article.extended.to_s,
        
      
        

          
          
                :mt_excerpt        => article.excerpt.to_s,
        
      
        

          
          
                :mt_keywords       => article.tags.collect { |p| p.name }.join(', '),
        
      
        

          
          
                :mt_allow_comments => article.allow_comments? ? 1 : 0,
        
      
        

          
          
                :mt_allow_pings    => article.allow_pings? ? 1 : 0,
        
      
        

          
          
                :mt_convert_breaks => (article.text_filter.name.to_s rescue ''),
        
      
        

          
          
                :mt_tb_ping_urls   => article.pings.collect { |p| p.url },
        
      
        

          
          
                :dateCreated       => (article.published_at.utc rescue '')
        
      
        

          
          
                )
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          module MovableTypeStructs
        
      
        

          2
          
            class ArticleTitle < ActionWebService::Struct
        
      
        

          2
          
              member :dateCreated,  :time
        
      
        

          2
          
              member :userid,       :string
        
      
        

          2
          
              member :postid,       :string
        
      
        

          2
          
              member :title,        :string
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            class CategoryList < ActionWebService::Struct
        
      
        

          2
          
              member :categoryId,   :string
        
      
        

          2
          
              member :categoryName, :string
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            class CategoryPerPost < ActionWebService::Struct
        
      
        

          2
          
              member :categoryName, :string
        
      
        

          2
          
              member :categoryId,   :string
        
      
        

          2
          
              member :isPrimary,    :bool
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            class TextFilter < ActionWebService::Struct
        
      
        

          2
          
              member :key,    :string
        
      
        

          2
          
              member :label,  :string
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            class TrackBack < ActionWebService::Struct
        
      
        

          2
          
              member :pingTitle,  :string
        
      
        

          2
          
              member :pingURL,    :string
        
      
        

          2
          
              member :pingIP,     :string
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          2
          
          class MovableTypeApi < ActionWebService::API::Base
        
      
        

          2
          
            inflect_names false
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getCategoryList,
        
      
        

          
          
              :expects => [ {:blogid => :string}, {:username => :string}, {:password => :string} ],
        
      
        

          
          
              :returns => [[MovableTypeStructs::CategoryList]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getPostCategories,
        
      
        

          
          
              :expects => [ {:postid => :string}, {:username => :string}, {:password => :string} ],
        
      
        

          
          
              :returns => [[MovableTypeStructs::CategoryPerPost]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getRecentPostTitles,
        
      
        

          
          
              :expects => [ {:blogid => :string}, {:username => :string}, {:password => :string}, {:numberOfPosts => :int} ],
        
      
        

          
          
              :returns => [[MovableTypeStructs::ArticleTitle]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :setPostCategories,
        
      
        

          
          
              :expects => [ {:postid => :string}, {:username => :string}, {:password => :string}, {:categories => [MovableTypeStructs::CategoryPerPost]} ],
        
      
        

          
          
              :returns => [:bool]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :supportedMethods,
        
      
        

          
          
              :expects => [],
        
      
        

          
          
              :returns => [[:string]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :supportedTextFilters,
        
      
        

          
          
              :expects => [],
        
      
        

          
          
              :returns => [[MovableTypeStructs::TextFilter]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :getTrackbackPings,
        
      
        

          
          
              :expects => [ {:postid => :string}],
        
      
        

          
          
              :returns => [[MovableTypeStructs::TrackBack]]
        
      
        

          
          
          
        
      
        

          2
          
            api_method :publishPost,
        
      
        

          
          
              :expects => [ {:postid => :string}, {:username => :string}, {:password => :string} ],
        
      
        

          
          
              :returns => [:bool]
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          2
          
          class MovableTypeService < TypoWebService
        
      
        

          2
          
            web_service_api MovableTypeApi
        
      
        

          
          
          
        
      
        

          2
          
            before_invocation :authenticate, :except => [:getTrackbackPings, :supportedMethods, :supportedTextFilters]
        
      
        

          
          
          
        
      
        

          2
          
            def getRecentPostTitles(blogid, username, password, numberOfPosts)
        
      
        

          
          
              Article.find(:all,:order => "created_at DESC", :limit => numberOfPosts).collect do |article|
        
      
        

          
          
                MovableTypeStructs::ArticleTitle.new(
        
      
        

          
          
                      :dateCreated => article.created_at,
        
      
        

          
          
                      :userid      => blogid.to_s,
        
      
        

          
          
                      :postid      => article.id.to_s,
        
      
        

          
          
                      :title       => article.title
        
      
        

          
          
                    )
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def getCategoryList(blogid, username, password)
        
      
        

          
          
              Category.find(:all).collect do |c|
        
      
        

          
          
                MovableTypeStructs::CategoryList.new(
        
      
        

          
          
                    :categoryId   => c.id,
        
      
        

          
          
                    :categoryName => c.name
        
      
        

          
          
                  )
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def getPostCategories(postid, username, password)
        
      
        

          
          
              Article.find(postid).categorizations.collect do |c|
        
      
        

          
          
                MovableTypeStructs::CategoryPerPost.new(
        
      
        

          
          
                    :categoryName => c.category.name,
        
      
        

          
          
                    :categoryId   => c.category_id.to_i,
        
      
        

          
          
                    :isPrimary    => c.is_primary
        
      
        

          
          
                  )
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def setPostCategories(postid, username, password, categories)
        
      
        

          
          
              article = Article.find(postid)
        
      
        

          
          
              article.categories.clear if categories != nil
        
      
        

          
          
          
        
      
        

          
          
              for c in categories
        
      
        

          
          
                category = Category.find(c['categoryId'])
        
      
        

          
          
                article.add_category(category, c['isPrimary'])
        
      
        

          
          
              end
        
      
        

          
          
              article.save
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def supportedMethods()
        
      
        

          
          
              MovableTypeApi.api_methods.keys.collect { |method| method.to_s }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Support for markdown and textile formatting dependant on the relevant
        
      
        

          
          
            # translators being available.
        
      
        

          2
          
            def supportedTextFilters()
        
      
        

          
          
              TextFilter.find(:all).collect do |filter|
        
      
        

          
          
                MovableTypeStructs::TextFilter.new(:key => filter.name, :label => filter.description)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def getTrackbackPings(postid)
        
      
        

          
          
              article = Article.find(postid)
        
      
        

          
          
              article.trackbacks.collect do |t|
        
      
        

          
          
                MovableTypeStructs::TrackBack.new(
        
      
        

          
          
                    :pingTitle  => t.title.to_s,
        
      
        

          
          
                    :pingURL    => t.url.to_s,
        
      
        

          
          
                    :pingIP     => t.ip.to_s
        
      
        

          
          
                  )
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def publishPost(postid, username, password)
        
      
        

          
          
              article = Article.find(postid)
        
      
        

          
          
              article.published = true
        
      
        

          
          
              article.save
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class TypoWebService < ActionWebService::Base
        
      
        

          2
          
            attr_accessor :controller
        
      
        

          
          
          
        
      
        

          2
          
            def initialize(controller)
        
      
        

          
          
              @controller = controller
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def this_blog
        
      
        

          
          
              controller.send(:this_blog)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            protected
        
      
        

          
          
          
        
      
        

          2
          
            def authenticate(name, args)
        
      
        

          
          
              method = self.class.web_service_api.api_methods[name]
        
      
        

          
          
          
        
      
        

          
          
              h = method.expects_to_hash(args)
        
      
        

          
          
              raise "Invalid login" unless @user=User.authenticate(h[:username], h[:password])
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class AccountsController < ApplicationController
        
      
        

          
          
          
        
      
        

          2
          
            before_filter :verify_config
        
      
        

          2
          
            before_filter :verify_users, :only => [:login, :recover_password]
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          
          
              if User.count.zero?
        
      
        

          
          
                redirect_to :action => 'signup'
        
      
        

          
          
              else
        
      
        

          
          
                redirect_to :action => 'login'
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def login
        
      
        

          4
          
              if session[:user_id] && session[:user_id] == self.current_user.id
        
      
        

          
          
                redirect_back_or_default :controller => "admin/dashboard", :action => "index"
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          4
          
              @page_title = "#{this_blog.blog_name} - #{_('login')}"
        
      
        

          
          
          
        
      
        

          4
          
              if request.post?
        
      
        

          2
          
                self.current_user = User.authenticate(params[:user][:login], params[:user][:password])
        
      
        

          
          
          
        
      
        

          2
          
                if logged_in?
        
      
        

          2
          
                  session[:user_id] = self.current_user.id
        
      
        

          
          
          
        
      
        

          2
          
                  if params[:remember_me] == "1"
        
      
        

          
          
                    self.current_user.remember_me unless self.current_user.remember_token?
        
      
        

          
          
                    cookies[:auth_token] = {
        
      
        

          
          
                      :value => self.current_user.remember_token,
        
      
        

          
          
                      :expires => self.current_user.remember_token_expires_at,
        
      
        

          
          
                      :httponly => true # Help prevent auth_token theft.
        
      
        

          
          
                    }
        
      
        

          
          
                  end
        
      
        

          2
          
                  add_to_cookies(:typo_user_profile, self.current_user.profile_label, '/')
        
      
        

          
          
          
        
      
        

          2
          
                  self.current_user.update_connection_time
        
      
        

          2
          
                  flash[:notice]  = _("Login successful")
        
      
        

          2
          
                  redirect_back_or_default :controller => "admin/dashboard", :action => "index"
        
      
        

          
          
                else
        
      
        

          
          
                  flash.now[:error]  = _("Login unsuccessful")
        
      
        

          
          
                  @login = params[:user][:login]
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def signup
        
      
        

          
          
              @page_title = "#{this_blog.blog_name} - #{_('signup')}"
        
      
        

          
          
              unless User.count.zero? or this_blog.allow_signup == 1
        
      
        

          
          
                redirect_to :action => 'login'
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @user = User.new(params[:user])
        
      
        

          
          
          
        
      
        

          
          
              if request.post?
        
      
        

          
          
                @user.password = generate_password
        
      
        

          
          
                session[:tmppass] = @user.password
        
      
        

          
          
                @user.name = @user.login
        
      
        

          
          
                if @user.save
        
      
        

          
          
                  self.current_user = @user
        
      
        

          
          
                  session[:user_id] = @user.id
        
      
        

          
          
          
        
      
        

          
          
                  redirect_to :controller => "accounts", :action => "confirm"
        
      
        

          
          
                  return
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def recover_password
        
      
        

          
          
              @page_title = "#{this_blog.blog_name} - #{_('Recover your password')}"
        
      
        

          
          
              if request.post?
        
      
        

          
          
                @user = User.find(:first, :conditions => ["login = ? or email = ?", params[:user][:login], params[:user][:login]])
        
      
        

          
          
          
        
      
        

          
          
                if @user
        
      
        

          
          
                  @user.password = generate_password
        
      
        

          
          
                  @user.save
        
      
        

          
          
                  flash[:notice] = _("An email has been successfully sent to your address with your new password")
        
      
        

          
          
                  redirect_to :action => 'login'
        
      
        

          
          
                else
        
      
        

          
          
                  flash[:error] = _("Oops, something wrong just happened")
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def logout
        
      
        

          
          
              flash[:notice]  = _("Successfully logged out")
        
      
        

          
          
              self.current_user.forget_me
        
      
        

          
          
              self.current_user = nil
        
      
        

          
          
              session[:user_id] = nil
        
      
        

          
          
              cookies.delete :auth_token
        
      
        

          
          
              cookies.delete :typo_user_profile
        
      
        

          
          
              redirect_to :action => 'login'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          2
          
            def generate_password
        
      
        

          
          
              chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
        
      
        

          
          
              newpass = ""
        
      
        

          
          
              1.upto(7) { |i| newpass << chars[rand(chars.size-1)] }
        
      
        

          
          
              return newpass
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def verify_users
        
      
        

          4
          
              redirect_to(:controller => "accounts", :action => "signup") if User.count == 0
        
      
        

          4
          
              true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def verify_config
        
      
        

          8
          
              redirect_to :controller => "setup", :action => "index" if  ! this_blog.configured?
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::BaseController < ApplicationController
        
      
        

          2
          
            cattr_accessor :look_for_migrations
        
      
        

          2
          
            @@look_for_migrations = true
        
      
        

          2
          
            layout 'administration'
        
      
        

          2
          
            before_filter :login_required, :except => [ :login, :signup ]
        
      
        

          2
          
            before_filter :look_for_needed_db_updates, :except => [:login, :signup, :update_database, :migrate]
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          2
          
            def look_for_needed_db_updates
        
      
        

          11
          
              if Migrator.offer_migration_when_available
        
      
        

          
          
                redirect_to :controller => '/admin/settings', :action => 'update_database' if Migrator.current_schema_version != Migrator.max_schema_version
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'find'
        
      
        

          
          
          
        
      
        

          2
          
          class Admin::CacheController < Admin::BaseController
        
      
        

          2
          
            def index
        
      
        

          
          
              @cache_size = 0
        
      
        

          
          
              @cache_number = 0
        
      
        

          
          
          
        
      
        

          
          
              FileUtils.mkdir_p(TypoBlog::Application.config.action_controller.page_cache_directory) unless File.exists?(TypoBlog::Application.config.action_controller.page_cache_directory)
        
      
        

          
          
          
        
      
        

          
          
              if request.post?
        
      
        

          
          
                begin
        
      
        

          
          
                  PageCache.sweep_all
        
      
        

          
          
                  flash.now[:notice] = _("Cache was successfully sweeped")
        
      
        

          
          
                rescue
        
      
        

          
          
                  flash.now[:error] = _("Oops, something wrong happened. Cache could not be cleaned")
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              Find.find(TypoBlog::Application.config.action_controller.page_cache_directory) do |path|
        
      
        

          
          
                if FileTest.directory?(path)
        
      
        

          
          
                  if File.basename(path)[0] == ?.
        
      
        

          
          
                    Find.prune
        
      
        

          
          
                  else
        
      
        

          
          
                    next
        
      
        

          
          
                  end
        
      
        

          
          
                else
        
      
        

          
          
                  @cache_size += FileTest.size(path)
        
      
        

          
          
                  @cache_number += 1
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::CategoriesController < Admin::BaseController
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def index; redirect_to :action => 'new' ; end
        
      
        

          5
          
            def edit; new_or_edit;  end
        
      
        

          
          
          
        
      
        

          2
          
            def new 
        
      
        

          3
          
              respond_to do |format|
        
      
        

          6
          
                format.html { new_or_edit }
        
      
        

          3
          
                format.js { 
        
      
        

          
          
                  @category = Category.new
        
      
        

          
          
                }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def destroy
        
      
        

          
          
              @record = Category.find(params[:id])
        
      
        

          
          
              return(render 'admin/shared/destroy') unless request.post?
        
      
        

          
          
          
        
      
        

          
          
              @record.destroy
        
      
        

          
          
              redirect_to :action => 'new'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          
          
          
        
      
        

          2
          
            def new_or_edit
        
      
        

          6
          
              @categories = Category.find(:all)
        
      
        

          
          
              #@category = Category.find(params[:id])
        
      
        

          6
          
              if params[:id]
        
      
        

          2
          
                @category = Category.find(params[:id])
        
      
        

          
          
              else
        
      
        

          4
          
                @category = Category.new
        
      
        

          
          
              end
        
      
        

          6
          
              @category.attributes = params[:category]
        
      
        

          6
          
              if request.post?
        
      
        

          2
          
                respond_to do |format|
        
      
        

          4
          
                  format.html { save_category }
        
      
        

          2
          
                  format.js do 
        
      
        

          
          
                    @category.save
        
      
        

          
          
                    @article = Article.new
        
      
        

          
          
                    @article.categories << @category
        
      
        

          
          
                    return render(:partial => 'admin/content/categories')
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          2
          
                return
        
      
        

          
          
              end
        
      
        

          4
          
              render 'new'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def save_category
        
      
        

          2
          
              if @category.save!
        
      
        

          2
          
                flash[:notice] = _('Category was successfully saved.')
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] = _('Category could not be saved.')
        
      
        

          
          
              end
        
      
        

          2
          
              redirect_to :action => 'new'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'base64'
        
      
        

          
          
          
        
      
        

          2
          
          module Admin; end
        
      
        

          2
          
          class Admin::ContentController < Admin::BaseController
        
      
        

          2
          
            layout "administration", :except => [:show, :autosave]
        
      
        

          
          
          
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def auto_complete_for_article_keywords
        
      
        

          
          
              @items = Tag.find_with_char params[:article][:keywords].strip
        
      
        

          
          
              render :inline => "<%= raw auto_complete_result @items, 'name' %>"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          1
          
              @search = params[:search] ? params[:search] : {}
        
      
        

          
          
              
        
      
        

          1
          
              @articles = Article.search_with_pagination(@search, {:page => params[:page], :per_page => this_blog.admin_display_elements})
        
      
        

          
          
          
        
      
        

          1
          
              if request.xhr?
        
      
        

          
          
                render :partial => 'article_list', :locals => { :articles => @articles }
        
      
        

          
          
              else
        
      
        

          1
          
                @article = Article.new(params[:article])
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def new
        
      
        

          2
          
              new_or_edit
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def edit
        
      
        

          
          
              @article = Article.find(params[:id])
        
      
        

          
          
              unless @article.access_by? current_user
        
      
        

          
          
                redirect_to :action => 'index'
        
      
        

          
          
                flash[:error] = _("Error, you are not allowed to perform this action")
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
              new_or_edit
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def destroy
        
      
        

          
          
              @record = Article.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              unless @record.access_by?(current_user)
        
      
        

          
          
                flash[:error] = _("Error, you are not allowed to perform this action")
        
      
        

          
          
                return(redirect_to :action => 'index')
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              return(render 'admin/shared/destroy') unless request.post?
        
      
        

          
          
          
        
      
        

          
          
              @record.destroy
        
      
        

          
          
              flash[:notice] = _("This article was deleted successfully")
        
      
        

          
          
              redirect_to :action => 'index'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def insert_editor
        
      
        

          
          
              editor = 'visual'
        
      
        

          
          
              editor = 'simple' if params[:editor].to_s == 'simple'
        
      
        

          
          
              current_user.editor = editor
        
      
        

          
          
              current_user.save!
        
      
        

          
          
          
        
      
        

          
          
              render :partial => "#{editor}_editor"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def category_add; do_add_or_remove_fu; end
        
      
        

          2
          
            alias_method :resource_add,    :category_add
        
      
        

          2
          
            alias_method :resource_remove, :category_add
        
      
        

          
          
          
        
      
        

          2
          
            def attachment_box_add
        
      
        

          
          
              render :update do |page|
        
      
        

          
          
                page["attachment_add_#{params[:id]}"].remove
        
      
        

          
          
                page.insert_html :bottom, 'attachments',
        
      
        

          
          
                    :partial => 'admin/content/attachment',
        
      
        

          
          
                    :locals => { :attachment_num => params[:id], :hidden => true }
        
      
        

          
          
                page.visual_effect(:toggle_appear, "attachment_#{params[:id]}")
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def attachment_save(attachment)
        
      
        

          
          
              begin
        
      
        

          
          
                Resource.create(:filename => attachment.original_filename, :mime => attachment.content_type.chomp, 
        
      
        

          
          
                                :created_at => Time.now).write_to_disk(attachment)
        
      
        

          
          
              rescue => e
        
      
        

          
          
                logger.info(e.message)
        
      
        

          
          
                nil
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def autosave
        
      
        

          
          
              id = params[:id]
        
      
        

          
          
              id = params[:article][:id] if params[:article] && params[:article][:id]
        
      
        

          
          
              @article = Article.get_or_build_article(id)
        
      
        

          
          
              @article.text_filter = current_user.text_filter if current_user.simple_editor?
        
      
        

          
          
          
        
      
        

          
          
              get_fresh_or_existing_draft_for_article
        
      
        

          
          
              
        
      
        

          
          
              @article.attributes = params[:article]
        
      
        

          
          
              @article.published = false
        
      
        

          
          
              set_article_author
        
      
        

          
          
              save_attachments
        
      
        

          
          
          
        
      
        

          
          
              set_article_title_for_autosave
        
      
        

          
          
          
        
      
        

          
          
              @article.state = "draft" unless @article.state == "withdrawn"
        
      
        

          
          
              if @article.save
        
      
        

          
          
                render(:update) do |page|
        
      
        

          
          
                  page.replace_html('autosave', hidden_field_tag('article[id]', @article.id))
        
      
        

          
          
                  page.replace_html('preview_link', link_to(_("Preview"), {:controller => '/articles', :action => 'preview', :id => @article.id}, {:target => 'new', :class => 'btn info'}))
        
      
        

          
          
                  page.replace_html('destroy_link', link_to_destroy_draft(@article))
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                return true
        
      
        

          
          
              end
        
      
        

          
          
              render :text => nil
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            protected
        
      
        

          
          
          
        
      
        

          2
          
            def get_fresh_or_existing_draft_for_article
        
      
        

          
          
              if @article.published and @article.id
        
      
        

          
          
                parent_id = @article.id
        
      
        

          
          
                @article = Article.drafts.child_of(parent_id).first || Article.new
        
      
        

          
          
                @article.allow_comments = this_blog.default_allow_comments
        
      
        

          
          
                @article.allow_pings    = this_blog.default_allow_pings
        
      
        

          
          
                @article.parent_id      = parent_id
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            attr_accessor :resources, :categories, :resource, :category
        
      
        

          
          
          
        
      
        

          2
          
            def do_add_or_remove_fu
        
      
        

          
          
              attrib, action = params[:action].split('_')
        
      
        

          
          
              @article = Article.find(params[:id])
        
      
        

          
          
              self.send("#{attrib}=", self.class.const_get(attrib.classify).find(params["#{attrib}_id"]))
        
      
        

          
          
              send("setup_#{attrib.pluralize}")
        
      
        

          
          
              @article.send(attrib.pluralize).send(real_action_for(action), send(attrib))
        
      
        

          
          
              @article.save
        
      
        

          
          
              render :partial => "show_#{attrib.pluralize}"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def real_action_for(action); { 'add' => :<<, 'remove' => :delete}[action]; end
        
      
        

          
          
          
        
      
        

          2
          
            def new_or_edit
        
      
        

          2
          
              id = params[:id]
        
      
        

          2
          
              id = params[:article][:id] if params[:article] && params[:article][:id]
        
      
        

          2
          
              @article = Article.get_or_build_article(id)
        
      
        

          2
          
              @article.text_filter = current_user.text_filter if current_user.simple_editor?
        
      
        

          
          
          
        
      
        

          2
          
              @post_types = PostType.find(:all)
        
      
        

          2
          
              if request.post?
        
      
        

          1
          
                if params[:article][:draft]
        
      
        

          
          
                  get_fresh_or_existing_draft_for_article
        
      
        

          
          
                else
        
      
        

          1
          
                  if not @article.parent_id.nil?
        
      
        

          
          
                    @article = Article.find(@article.parent_id)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              @article.keywords = Tag.collection_to_string @article.tags
        
      
        

          2
          
              @article.attributes = params[:article]
        
      
        

          
          
              # TODO: Consider refactoring, because double rescue looks... weird.
        
      
        

          
          
                  
        
      
        

          2
          
              @article.published_at = DateTime.strptime(params[:article][:published_at], "%B %e, %Y %I:%M %p GMT%z").utc rescue Time.parse(params[:article][:published_at]).utc rescue nil
        
      
        

          
          
          
        
      
        

          2
          
              if request.post?
        
      
        

          1
          
                set_article_author
        
      
        

          1
          
                save_attachments
        
      
        

          
          
                
        
      
        

          1
          
                @article.state = "draft" if @article.draft
        
      
        

          
          
          
        
      
        

          1
          
                if @article.save
        
      
        

          1
          
                  destroy_the_draft unless @article.draft
        
      
        

          1
          
                  set_article_categories
        
      
        

          1
          
                  set_the_flash
        
      
        

          1
          
                  redirect_to :action => 'index'
        
      
        

          1
          
                  return
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              @images = Resource.images_by_created_at.page(params[:page]).per(10)
        
      
        

          1
          
              @resources = Resource.without_images_by_filename
        
      
        

          1
          
              @macros = TextFilter.macro_filters
        
      
        

          1
          
              render 'new'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def set_the_flash
        
      
        

          1
          
              case params[:action]
        
      
        

          
          
              when 'new'
        
      
        

          1
          
                flash[:notice] = _('Article was successfully created')
        
      
        

          
          
              when 'edit'
        
      
        

          
          
                flash[:notice] = _('Article was successfully updated.')
        
      
        

          
          
              else
        
      
        

          
          
                raise "I don't know how to tidy up action: #{params[:action]}"
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def destroy_the_draft
        
      
        

          1
          
              Article.all(:conditions => { :parent_id => @article.id }).map(&:destroy)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def set_article_author
        
      
        

          1
          
              return if @article.author
        
      
        

          1
          
              @article.author = current_user.login
        
      
        

          1
          
              @article.user   = current_user
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def set_article_title_for_autosave
        
      
        

          
          
              if @article.title.blank?
        
      
        

          
          
                lastid = Article.find(:first, :order => 'id DESC').id
        
      
        

          
          
                @article.title = "Draft article " + lastid.to_s
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def save_attachments
        
      
        

          1
          
              return if params[:attachments].nil?
        
      
        

          
          
              params[:attachments].each do |k,v|
        
      
        

          
          
                a = attachment_save(v)
        
      
        

          
          
                @article.resources << a unless a.nil?
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def set_article_categories
        
      
        

          1
          
              @article.categorizations.clear
        
      
        

          1
          
              if params[:categories]
        
      
        

          
          
                Category.find(params[:categories]).each do |cat|
        
      
        

          
          
                  @article.categories << cat
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def def_build_body
        
      
        

          
          
              if @article.body =~ /<!--more-->/
        
      
        

          
          
                body = @article.body.split('<!--more-->')
        
      
        

          
          
                @article.body = body[0]
        
      
        

          
          
                @article.extended = body[1]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def setup_resources
        
      
        

          
          
              @resources = Resource.by_created_at
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::DashboardController < Admin::BaseController
        
      
        

          2
          
            require 'open-uri'
        
      
        

          2
          
            require 'time'
        
      
        

          2
          
            require 'rexml/document'
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          2
          
              @newposts = Article.count(:all, :conditions => ['published = ? and published_at > ?', true, current_user.last_venue])
        
      
        

          2
          
              @newcomments = Feedback.count(:all, :conditions =>['state in (?,?) and published_at > ?', 'presumed_ham', 'ham', current_user.last_venue])
        
      
        

          2
          
              comments
        
      
        

          2
          
              lastposts
        
      
        

          2
          
              popular
        
      
        

          2
          
              statistics
        
      
        

          2
          
              inbound_links
        
      
        

          2
          
              typo_dev
        
      
        

          2
          
              typo_version
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          
          
          
        
      
        

          2
          
            def statistics
        
      
        

          2
          
              @statposts = Article.published.count
        
      
        

          2
          
              @statuserposts = Article.published.count(:conditions => {:user_id => current_user.id})
        
      
        

          2
          
              @statcomments = Comment.count(:all, :conditions => "state != 'spam'")
        
      
        

          2
          
              @statspam = Comment.count(:all, :conditions => { :state => 'spam' })
        
      
        

          2
          
              @presumedspam = Comment.count(:all, :conditions => { :state => 'presumed_spam' })
        
      
        

          2
          
              @categories = Category.count(:all)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def comments
        
      
        

          
          
              @comments ||=
        
      
        

          
          
                Comment.find(:all,
        
      
        

          
          
                             :limit => 5,
        
      
        

          
          
                             :conditions => ['published = ?', true],
        
      
        

          2
          
                             :order => 'created_at DESC')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def lastposts
        
      
        

          2
          
              @recent_posts = Article.find(:all,
        
      
        

          
          
                                           :conditions => ["published = ?", true],
        
      
        

          
          
                                           :order => 'published_at DESC',
        
      
        

          
          
                                           :limit => 5)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def popular
        
      
        

          2
          
              @bestof = Article.find(:all,
        
      
        

          
          
                                     :select => 'contents.*, comment_counts.count AS comment_count',
        
      
        

          
          
                                     :from => "contents, (SELECT feedback.article_id AS article_id, COUNT(feedback.id) as count FROM feedback WHERE feedback.state IN ('presumed_ham', 'ham') GROUP BY feedback.article_id ORDER BY count DESC LIMIT 9) AS comment_counts",
        
      
        

          
          
                                     :conditions => ['comment_counts.article_id = contents.id AND published = ?', true],
        
      
        

          
          
                                     :order => 'comment_counts.count DESC',
        
      
        

          
          
                                     :limit => 5)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def inbound_links
        
      
        

          2
          
              url = "http://www.google.com/search?q=link:#{this_blog.base_url}&tbm=blg&output=rss"
        
      
        

          2
          
              open(url) do |http|
        
      
        

          
          
                @inbound_links = parse_rss(http.read).reverse
        
      
        

          
          
              end
        
      
        

          
          
            rescue
        
      
        

          2
          
              @inbound_links = nil
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def typo_version
        
      
        

          2
          
              get_typo_version
        
      
        

          2
          
              version =  @typo_version ? @typo_version.split('.') : TYPO_VERSION.to_s.split('.')
        
      
        

          
          
          
        
      
        

          2
          
              if version[0].to_i > TYPO_MAJOR.to_i
        
      
        

          
          
                flash.now[:error] = _("You are late from at least one major version of Typo. You should upgrade immediately. Download and install %s", "<a href='http://typosphere.org/stable.tgz'>#{_("the latest Typo version")}</a>").html_safe
        
      
        

          2
          
              elsif version[1].to_i > TYPO_SUB.to_i
        
      
        

          
          
                flash.now[:warning] = _("There's a new version of Typo available which may contain important bug fixes. Why don't you upgrade to %s ?", "<a href='http://typosphere.org/stable.tgz'>#{_("the latest Typo version")}</a>").html_safe
        
      
        

          2
          
              elsif version[2].to_i > TYPO_MINOR.to_i
        
      
        

          
          
                flash.now[:notice] = _("There's a new version of Typo available. Why don't you upgrade to %s ?", "<a href='http://typosphere.org/stable.tgz'>#{_("the latest Typo version")}</a>").html_safe
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def get_typo_version
        
      
        

          2
          
              url = "http://blog.typosphere.org/version.txt"
        
      
        

          2
          
              open(url) do |http|
        
      
        

          
          
                @typo_version = http.read[0..5]
        
      
        

          
          
              end
        
      
        

          
          
            rescue
        
      
        

          2
          
              @typo_version = nil
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def typo_dev
        
      
        

          2
          
              url = "http://blog.typosphere.org/articles.rss"
        
      
        

          2
          
              open(url) do |http|
        
      
        

          
          
                @typo_links = parse_rss(http.read)[0..4]
        
      
        

          
          
              end
        
      
        

          
          
            rescue
        
      
        

          2
          
              @typo_links = nil
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          
          
          
        
      
        

          2
          
            class RssItem < Struct.new(:link, :title, :description, :description_link, :date, :author)
        
      
        

          2
          
              def to_s; title end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def parse_rss(body)
        
      
        

          
          
              xml = REXML::Document.new(body)
        
      
        

          
          
          
        
      
        

          
          
              items        = []
        
      
        

          
          
              link         = REXML::XPath.match(xml, "//channel/link/text()").first.value rescue ""
        
      
        

          
          
              title        = REXML::XPath.match(xml, "//channel/title/text()").first.value rescue ""
        
      
        

          
          
          
        
      
        

          
          
              REXML::XPath.each(xml, "//item/") do |elem|
        
      
        

          
          
                item = RssItem.new
        
      
        

          
          
                item.title       = REXML::XPath.match(elem, "title/text()").first.value rescue ""
        
      
        

          
          
                item.link        = REXML::XPath.match(elem, "link/text()").first.value rescue ""
        
      
        

          
          
                item.description = REXML::XPath.match(elem, "description/text()").first.value rescue ""
        
      
        

          
          
                item.author      = REXML::XPath.match(elem, "dc:publisher/text()").first.value rescue ""
        
      
        

          
          
                item.date        = Time.mktime(*ParseDate.parsedate(REXML::XPath.match(elem, "dc:date/text()").first.value)) rescue Time.now
        
      
        

          
          
          
        
      
        

          
          
                item.description_link = item.description
        
      
        

          
          
                item.description.gsub!(/<\/?a\b.*?>/, "") # remove all <a> tags
        
      
        

          
          
                items << item
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              items.sort_by { |item| item.date }
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::FeedbackController < Admin::BaseController
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          
          
              conditions = ['1 = 1', {}]
        
      
        

          
          
          
        
      
        

          
          
              if params[:search]
        
      
        

          
          
                conditions.first << ' and (url like :pattern or author like :pattern or title like :pattern or ip like :pattern or email like :pattern)'
        
      
        

          
          
                conditions.last.merge!(:pattern => "%#{params[:search]}%")
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if params[:published] == 'f'
        
      
        

          
          
                conditions.first << ' and (published = :published)'
        
      
        

          
          
                conditions.last.merge!(:published => false)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if params[:confirmed] == 'f'
        
      
        

          
          
                conditions.first << ' AND (status_confirmed = :status_confirmed)'
        
      
        

          
          
                conditions.last.merge!(:status_confirmed => false)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if params[:ham] == 'f'
        
      
        

          
          
                conditions.first << ' AND state = :state '
        
      
        

          
          
                conditions.last.merge!(:state => 'ham')
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if params[:spam] == 'f'
        
      
        

          
          
                conditions.first << ' AND state = :state '
        
      
        

          
          
                conditions.last.merge!(:state => 'spam')
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if params[:presumed_ham] == 'f'
        
      
        

          
          
                conditions.first << ' AND state = :state '
        
      
        

          
          
                conditions.last.merge!(:state => 'presumed_ham')
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if params[:presumed_spam] == 'f'
        
      
        

          
          
                conditions.first << ' AND state = :state '
        
      
        

          
          
                conditions.last.merge!(:state => 'presumed_spam')
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # no need params[:page] if empty of == 0, there are a crash otherwise
        
      
        

          
          
              if params[:page].blank? || params[:page] == "0"
        
      
        

          
          
                params.delete(:page)
        
      
        

          
          
              end
        
      
        

          
          
              @feedback = Feedback.where(conditions).order('feedback.created_at desc').page(params[:page]).per(this_blog.admin_display_elements)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def article
        
      
        

          
          
              @article = Article.find(params[:id])
        
      
        

          
          
              if params[:ham] && params[:spam].blank?
        
      
        

          
          
                @feedback = @article.comments.ham
        
      
        

          
          
              end
        
      
        

          
          
              if params[:spam] && params[:ham].blank?
        
      
        

          
          
                @feedback = @article.comments.spam
        
      
        

          
          
              end
        
      
        

          
          
              @feedback ||= @article.comments
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def destroy
        
      
        

          
          
              @record = Feedback.find params[:id]
        
      
        

          
          
          
        
      
        

          
          
              unless @record.article.user_id == current_user.id
        
      
        

          
          
                unless current_user.admin?
        
      
        

          
          
                  return redirect_to :controller => 'admin/feedback', :action => :index
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              return(render 'admin/shared/destroy') unless request.post?
        
      
        

          
          
          
        
      
        

          
          
              begin
        
      
        

          
          
                @record.destroy
        
      
        

          
          
                flash[:notice] = _("Deleted")
        
      
        

          
          
              rescue ActiveRecord::RecordNotFound
        
      
        

          
          
                flash[:notice] = _("Not found")
        
      
        

          
          
              end
        
      
        

          
          
              redirect_to :action => 'article', :id => @record.article.id
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def create
        
      
        

          
          
              @article = Article.find(params[:article_id])
        
      
        

          
          
              @comment = @article.comments.build(params[:comment])
        
      
        

          
          
              @comment.user_id = current_user.id
        
      
        

          
          
          
        
      
        

          
          
              if request.post? and @comment.save
        
      
        

          
          
                # We should probably wave a spam filter over this, but for now, just mark it as published.
        
      
        

          
          
                @comment.mark_as_ham!
        
      
        

          
          
                flash[:notice] = _('Comment was successfully created.')
        
      
        

          
          
              end
        
      
        

          
          
              redirect_to :action => 'article', :id => @article.id
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def edit
        
      
        

          
          
              @comment = Comment.find(params[:id])
        
      
        

          
          
              @article = @comment.article
        
      
        

          
          
              unless @article.access_by? current_user
        
      
        

          
          
                redirect_to :action => 'index'
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def update
        
      
        

          
          
              comment = Comment.find(params[:id])
        
      
        

          
          
              unless comment.article.access_by? current_user
        
      
        

          
          
                redirect_to :action => 'index'
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
              comment.attributes = params[:comment]
        
      
        

          
          
              if request.post? and comment.save
        
      
        

          
          
                flash[:notice] = _('Comment was successfully updated.')
        
      
        

          
          
                redirect_to :action => 'article', :id => comment.article.id
        
      
        

          
          
              else
        
      
        

          
          
                redirect_to :action => 'edit', :id => comment.id
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def change_state
        
      
        

          
          
              return unless request.xhr?
        
      
        

          
          
          
        
      
        

          
          
              feedback = Feedback.find(params[:id])
        
      
        

          
          
              if (feedback.state.to_s.downcase == 'spam')
        
      
        

          
          
                feedback.mark_as_ham!
        
      
        

          
          
              else
        
      
        

          
          
                feedback.mark_as_spam!
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              template = (feedback.state.to_s.downcase == 'spam') ? 'spam' : 'ham'
        
      
        

          
          
              render(:update) do |page|
        
      
        

          
          
                if params[:context] != 'listing'
        
      
        

          
          
                  page.visual_effect :fade, "feedback_#{feedback.id}"
        
      
        

          
          
                else
        
      
        

          
          
                  page.replace("feedback_#{feedback.id}", :partial => template, :locals => {:comment => feedback})
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def bulkops
        
      
        

          
          
              ids = (params[:feedback_check]||{}).keys.map(&:to_i)
        
      
        

          
          
              items = Feedback.find(ids)
        
      
        

          
          
              @unexpired = true
        
      
        

          
          
          
        
      
        

          
          
              bulkop = params[:bulkop_top].empty? ? params[:bulkop_bottom] : params[:bulkop_top]
        
      
        

          
          
              case bulkop
        
      
        

          
          
              when 'Delete Checked Items'
        
      
        

          
          
                count = 0
        
      
        

          
          
                ids.each do |id|
        
      
        

          
          
                  count += Feedback.delete(id) ## XXX Should this be #destroy?
        
      
        

          
          
                end
        
      
        

          
          
                flash[:notice] = _("Deleted %d item(s)",count)
        
      
        

          
          
          
        
      
        

          
          
                items.each do |i|
        
      
        

          
          
                  i.invalidates_cache? or next
        
      
        

          
          
                  flush_cache
        
      
        

          
          
                  return
        
      
        

          
          
                end
        
      
        

          
          
              when 'Mark Checked Items as Ham'
        
      
        

          
          
                update_feedback(items, :mark_as_ham!)
        
      
        

          
          
                flash[:notice]= _("Marked %d item(s) as Ham",ids.size)
        
      
        

          
          
              when 'Mark Checked Items as Spam'
        
      
        

          
          
                update_feedback(items, :mark_as_spam!)
        
      
        

          
          
                flash[:notice]= _("Marked %d item(s) as Spam",ids.size)
        
      
        

          
          
              when 'Confirm Classification of Checked Items'
        
      
        

          
          
                update_feedback(items, :confirm_classification!)
        
      
        

          
          
                flash[:notice] = _("Confirmed classification of %s item(s)",ids.size)
        
      
        

          
          
              when 'Delete all spam'
        
      
        

          
          
                delete_all_spam
        
      
        

          
          
              else
        
      
        

          
          
                flash[:notice] = _("Not implemented")
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if params[:article_id]
        
      
        

          
          
                redirect_to :action => 'article', :id => params[:article_id], :confirmed => params[:confirmed], :published => params[:published]
        
      
        

          
          
              else
        
      
        

          
          
                redirect_to :action => 'index', :page => params[:page], :search => params[:search], :confirmed => params[:confirmed], :published => params[:published]
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            protected
        
      
        

          
          
          
        
      
        

          2
          
            def delete_all_spam
        
      
        

          
          
              if request.post?
        
      
        

          
          
                Feedback.delete_all(['state = ?', 'spam'])
        
      
        

          
          
                flash[:notice] = _("All spam have been deleted")
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def update_feedback(items, method)
        
      
        

          
          
              items.each do |value|
        
      
        

          
          
                value.send(method)
        
      
        

          
          
                @unexpired && value.invalidates_cache? or next
        
      
        

          
          
                flush_cache
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def flush_cache
        
      
        

          
          
              @unexpired = false
        
      
        

          
          
              PageCache.sweep_all
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # coding: utf-8
        
      
        

          2
          
          require 'base64'
        
      
        

          
          
          
        
      
        

          2
          
          class Admin::PagesController < Admin::BaseController
        
      
        

          2
          
            layout "administration", :except => 'show'
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          
          
              @search = params[:search] ? params[:search] : {}
        
      
        

          
          
              @pages = Page.search_paginate(@search, :page => params[:page], :per_page => this_blog.admin_display_elements)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def new
        
      
        

          
          
              @macros = TextFilter.macro_filters
        
      
        

          
          
              @page = Page.new(params[:page])
        
      
        

          
          
              @page.user_id = current_user.id
        
      
        

          
          
              @page.text_filter ||= current_user.text_filter
        
      
        

          
          
              @images = Resource.where("mime LIKE '%image%'").order('created_at DESC').page(1).per(10)
        
      
        

          
          
              if request.post?
        
      
        

          
          
                @page.published_at = Time.now
        
      
        

          
          
                if @page.save
        
      
        

          
          
                  flash[:notice] = _('Page was successfully created.')
        
      
        

          
          
                  redirect_to :action => 'index'
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def edit
        
      
        

          
          
              @macros = TextFilter.macro_filters
        
      
        

          
          
              @images = Resource.where("mime LIKE '%image%'").page(1).order('created_at DESC').per(10)
        
      
        

          
          
              @page = Page.find(params[:id])
        
      
        

          
          
              @page.attributes = params[:page]
        
      
        

          
          
              if request.post? and @page.save
        
      
        

          
          
                flash[:notice] = _('Page was successfully updated.')
        
      
        

          
          
                redirect_to :action => 'index'
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def destroy
        
      
        

          
          
              @record = Page.find(params[:id])
        
      
        

          
          
              return(render 'admin/shared/destroy') unless request.post?
        
      
        

          
          
          
        
      
        

          
          
              @record.destroy
        
      
        

          
          
              redirect_to :action => 'index'    
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # TODO Duplicate with Admin::ContentController
        
      
        

          2
          
            def insert_editor
        
      
        

          
          
              editor = 'visual'
        
      
        

          
          
              editor = 'simple' if params[:editor].to_s == 'simple'
        
      
        

          
          
              current_user.editor = editor
        
      
        

          
          
              current_user.save!
        
      
        

          
          
          
        
      
        

          
          
              render :partial => "#{editor}_editor"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::PostTypesController < Admin::BaseController
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def index; redirect_to :action => 'new' ; end
        
      
        

          2
          
            def new; new_or_edit ; end
        
      
        

          2
          
            def edit; new_or_edit;  end
        
      
        

          
          
          
        
      
        

          2
          
            def destroy
        
      
        

          
          
              @record = PostType.find(params[:id])
        
      
        

          
          
              return(render 'admin/shared/destroy') unless request.post?
        
      
        

          
          
          
        
      
        

          
          
              Article.find(:all, :conditions => ["post_type = ?", @record.permalink]).each do |article|
        
      
        

          
          
                article.post_type = 'read'
        
      
        

          
          
                article.save
        
      
        

          
          
              end
        
      
        

          
          
              @record.destroy
        
      
        

          
          
              redirect_to :action => 'index'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          
          
          
        
      
        

          2
          
            def new_or_edit
        
      
        

          
          
              @post_types = PostType.find(:all)
        
      
        

          
          
              @post_type = case params[:id]
        
      
        

          
          
                          when nil
        
      
        

          
          
                            PostType.new
        
      
        

          
          
                          else
        
      
        

          
          
                            PostType.find(params[:id])
        
      
        

          
          
                          end
        
      
        

          
          
              @post_type.attributes = params[:post_type]
        
      
        

          
          
              if request.post?
        
      
        

          
          
                save_post_type
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
              render 'new'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def save_post_type
        
      
        

          
          
              if @post_type.save!
        
      
        

          
          
                flash[:notice] = _('Post Type was successfully saved.')
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] = _('Post Type could not be saved.')
        
      
        

          
          
              end
        
      
        

          
          
              redirect_to :action => 'index'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::ProfilesController < Admin::BaseController
        
      
        

          2
          
            helper Admin::UsersHelper
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          
          
              @user = current_user
        
      
        

          
          
              @profiles = Profile.find(:all, :order => 'id')
        
      
        

          
          
              @user.attributes = params[:user]
        
      
        

          
          
              if request.post? and @user.save
        
      
        

          
          
                current_user = @user
        
      
        

          
          
                flash[:notice] = _('User was successfully updated.')
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::RedirectsController < Admin::BaseController
        
      
        

          2
          
            def index; redirect_to :action => 'new' ; end
        
      
        

          2
          
            def edit; new_or_edit;  end
        
      
        

          2
          
            def new; new_or_edit;  end
        
      
        

          
          
              
        
      
        

          
          
          
        
      
        

          2
          
            def destroy
        
      
        

          
          
              @record = Redirect.find(params[:id])
        
      
        

          
          
              return(render 'admin/shared/destroy') unless request.post?
        
      
        

          
          
              
        
      
        

          
          
              @record.destroy
        
      
        

          
          
              flash[:notice] = _('Redirection was successfully deleted.')
        
      
        

          
          
              redirect_to :action => 'index'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          2
          
            def new_or_edit
        
      
        

          
          
              @redirects = Redirect.where("origin is null").order('created_at desc').page(params[:page]).per(this_blog.admin_display_elements)
        
      
        

          
          
              
        
      
        

          
          
              @redirect = case params[:id]
        
      
        

          
          
              when nil
        
      
        

          
          
                Redirect.new
        
      
        

          
          
              else
        
      
        

          
          
                Redirect.find(params[:id])
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @redirect.attributes = params[:redirect]
        
      
        

          
          
              if request.post?
        
      
        

          
          
                if @redirect.from_path.empty? || @redirect.from_path.nil?
        
      
        

          
          
                  @redirect.from_path = @redirect.shorten
        
      
        

          
          
                end
        
      
        

          
          
                save_redirect
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
              render 'new'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def save_redirect
        
      
        

          
          
              if @redirect.save!
        
      
        

          
          
                  flash[:notice] = _('Redirection was successfully saved.')
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] = _('Redirection could not be saved.')
        
      
        

          
          
              end
        
      
        

          
          
              redirect_to :action => 'index'
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::ResourcesController < Admin::BaseController
        
      
        

          2
          
            upload_status_for :file_upload, :status => :upload_status
        
      
        

          
          
          
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def upload
        
      
        

          
          
              begin
        
      
        

          
          
                if request.post?
        
      
        

          
          
                  file = params[:upload][:filename]
        
      
        

          
          
                  unless file.content_type
        
      
        

          
          
                    mime = 'text/plain'
        
      
        

          
          
                  else
        
      
        

          
          
                    mime = file.content_type.chomp
        
      
        

          
          
                  end
        
      
        

          
          
                  @up = Resource.create(:filename => file.original_filename, :mime => mime, :created_at => Time.now)
        
      
        

          
          
          
        
      
        

          
          
                  @up.write_to_disk(file)
        
      
        

          
          
          
        
      
        

          
          
                  @message = _('File uploaded: ')+ file.size.to_s
        
      
        

          
          
                  finish_upload_status "'#{@message}'"
        
      
        

          
          
                end
        
      
        

          
          
              rescue
        
      
        

          
          
                @message = "'" + _('Unable to upload') + " #{file.original_filename}'"
        
      
        

          
          
                @up.destroy unless @up.nil?
        
      
        

          
          
                raise
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def update
        
      
        

          
          
              @resource = Resource.find(params[:resource][:id])
        
      
        

          
          
              @resource.attributes = params[:resource]
        
      
        

          
          
          
        
      
        

          
          
              if request.post? and @resource.save
        
      
        

          
          
                flash[:notice] = _('Metadata was successfully updated.')
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] = _('Not all metadata was defined correctly.')
        
      
        

          
          
                @resource.errors.each do |meta_key,val|
        
      
        

          
          
                  flash[:error] << "<br />" + val
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              redirect_to :action => 'index'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def upload_status
        
      
        

          
          
              render :inline => "<%= upload_progress.completed_percent rescue 0 %> % " + _("complete"), :layout => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          
          
              @r = Resource.new
        
      
        

          
          
              @resources = Resource.order('created_at DESC').page(params[:page]).per(this_blog.admin_display_elements)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def get_thumbnails
        
      
        

          
          
              position = params[:position].to_i
        
      
        

          
          
              @resources = Resource.without_images.by_created_at.limit("#{position}, 10")
        
      
        

          
          
              render 'get_thumbnails', :layout => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def destroy
        
      
        

          
          
              begin
        
      
        

          
          
                @record = Resource.find(params[:id])
        
      
        

          
          
                mime = @record.mime
        
      
        

          
          
                return(render 'admin/shared/destroy') unless request.post?
        
      
        

          
          
                
        
      
        

          
          
                @record.destroy
        
      
        

          
          
                redirect_to :action => 'index'
        
      
        

          
          
              rescue
        
      
        

          
          
                raise
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::SeoController < Admin::BaseController
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          
          
              load_settings
        
      
        

          
          
              if File.exists? "#{::Rails.root.to_s}/public/robots.txt"
        
      
        

          
          
                @setting.robots = ""
        
      
        

          
          
                file = File.readlines("#{::Rails.root.to_s}/public/robots.txt")
        
      
        

          
          
                file.each do |line|
        
      
        

          
          
                  @setting.robots << line
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                build_robots
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def permalinks 
        
      
        

          
          
              if request.post?
        
      
        

          
          
                if params[:setting]['permalink_format'] and params[:setting]['permalink_format'] == 'custom'
        
      
        

          
          
                  params[:setting]['permalink_format'] = params[:setting]['custom_permalink']
        
      
        

          
          
                end
        
      
        

          
          
                update
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              load_settings
        
      
        

          
          
              if @setting.permalink_format != '/%year%/%month%/%day%/%title%' and
        
      
        

          
          
                @setting.permalink_format != '/%year%/%month%/%title%' and
        
      
        

          
          
                @setting.permalink_format != '/%title%'
        
      
        

          
          
                @setting.custom_permalink = @setting.permalink_format
        
      
        

          
          
                @setting.permalink_format = 'custom'
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          2
          
            def titles
        
      
        

          
          
              load_settings
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def update
        
      
        

          
          
              if request.post?
        
      
        

          
          
                Blog.transaction do
        
      
        

          
          
                  params[:setting].each { |k,v| this_blog.send("#{k.to_s}=", v) }
        
      
        

          
          
                  this_blog.save
        
      
        

          
          
                  flash[:notice] = _('config updated.')
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                save_robots unless params[:setting][:robots].blank?
        
      
        

          
          
          
        
      
        

          
          
                redirect_to :action => params[:from]
        
      
        

          
          
              end
        
      
        

          
          
            rescue ActiveRecord::RecordInvalid
        
      
        

          
          
              render params[:from]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          2
          
            def load_settings
        
      
        

          
          
              @setting = this_blog
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def save_robots
        
      
        

          
          
              if File.writable? "#{::Rails.root.to_s}/public/robots.txt"
        
      
        

          
          
                robots = File.new("#{::Rails.root.to_s}/public/robots.txt", "r+")
        
      
        

          
          
                robots.write(params[:setting][:robots])
        
      
        

          
          
                robots.close
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          2
          
            def build_robots
        
      
        

          
          
              robots = File.new("#{::Rails.root.to_s}/public/robots.txt", "w+")
        
      
        

          
          
              line = "User-agent: *\nAllow: /\nDisallow: /admin\n"
        
      
        

          
          
              robots.write(line)
        
      
        

          
          
              robots.close
        
      
        

          
          
              @setting.robots = line
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::SettingsController < Admin::BaseController
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          
          
              if this_blog.base_url.blank?
        
      
        

          
          
                this_blog.base_url = blog_base_url
        
      
        

          
          
              end
        
      
        

          
          
              load_settings
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def write; load_settings end
        
      
        

          2
          
            def feedback; load_settings end
        
      
        

          2
          
            def errors; load_settings; end
        
      
        

          
          
            
        
      
        

          2
          
            def redirect
        
      
        

          
          
              flash[:notice] = _("Please review and save the settings before continuing")
        
      
        

          
          
              redirect_to :action => "index"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def update
        
      
        

          
          
              if request.post?
        
      
        

          
          
                Blog.transaction do
        
      
        

          
          
                  params[:setting].each { |k,v| this_blog.send("#{k.to_s}=", v) }
        
      
        

          
          
                  this_blog.save
        
      
        

          
          
                  flash[:notice] = _('config updated.')
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                redirect_to :action => params[:from]
        
      
        

          
          
              end
        
      
        

          
          
            rescue ActiveRecord::RecordInvalid
        
      
        

          
          
              render params[:from]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def update_database
        
      
        

          
          
              @current_version = Migrator.current_schema_version
        
      
        

          
          
              @needed_version = Migrator.max_schema_version
        
      
        

          
          
              @support = Migrator.db_supports_migrations?
        
      
        

          
          
              @needed_migrations = Migrator.available_migrations[@current_version..@needed_version].collect do |mig|
        
      
        

          
          
                mig.scan(/\d+\_([\w_]+)\.rb$/).flatten.first.humanize
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def migrate
        
      
        

          
          
              if request.post?
        
      
        

          
          
                Migrator.migrate
        
      
        

          
          
                redirect_to :action => 'update_database'
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            private
        
      
        

          2
          
            def load_settings
        
      
        

          
          
              @setting = this_blog
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::SidebarController < Admin::BaseController
        
      
        

          2
          
            def index
        
      
        

          
          
              @available = available
        
      
        

          
          
              # Reset the staged position based on the active position.
        
      
        

          
          
              Sidebar.delete_all('active_position is null')
        
      
        

          
          
              flash_sidebars
        
      
        

          
          
              begin
        
      
        

          
          
                @active = Sidebar.find(:all, :order => 'active_position ASC') unless @active
        
      
        

          
          
              rescue => e
        
      
        

          
          
                logger.error e
        
      
        

          
          
                # Avoiding the view to crash
        
      
        

          
          
                @active = []
        
      
        

          
          
                flash[:error] = _("It seems something went wrong. Maybe some of your sidebars are actually missing and you should either reinstall them or remove them manually")
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def set_active
        
      
        

          
          
              # Get all available plugins
        
      
        

          
          
              klass_for = available.inject({}) do |hash, klass|
        
      
        

          
          
                hash.merge({ klass.short_name => klass })
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Get all already active plugins
        
      
        

          
          
              activemap = flash_sidebars.inject({}) do |h, sb_id|
        
      
        

          
          
                sb = Sidebar.find(sb_id.to_i)
        
      
        

          
          
                sb ? h.merge(sb.html_id => sb_id) : h
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Figure out which plugins are referenced by the params[:active] array and
        
      
        

          
          
              # lay them out in a easy accessible sequential array
        
      
        

          
          
              flash[:sidebars] = params[:active].map do |name|
        
      
        

          
          
                if klass_for.has_key?(name)
        
      
        

          
          
                  new_sidebar_id = klass_for[name].create.id
        
      
        

          
          
                  @new_item = Sidebar.find(new_sidebar_id)
        
      
        

          
          
                  new_sidebar_id
        
      
        

          
          
                elsif activemap.has_key?(name)
        
      
        

          
          
                  activemap[name]
        
      
        

          
          
                end
        
      
        

          
          
              end.compact
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def remove
        
      
        

          
          
              flash[:sidebars] = flash_sidebars.reject do |sb_id|
        
      
        

          
          
                sb_id == params[:id].to_i
        
      
        

          
          
              end
        
      
        

          
          
              @element_to_remove = params[:element]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def publish
        
      
        

          
          
              Sidebar.transaction do
        
      
        

          
          
                position = 0
        
      
        

          
          
                params[:configure] ||= { }
        
      
        

          
          
                # Crappy workaround to rails update_all bug with PgSQL / SQLite
        
      
        

          
          
                ActiveRecord::Base.connection.execute("update sidebars set active_position=null")
        
      
        

          
          
                flash_sidebars.each do |id|
        
      
        

          
          
                  sidebar = Sidebar.find(id)
        
      
        

          
          
                  sb_attribs = params[:configure][id.to_s] || {}
        
      
        

          
          
                  # If it's a checkbox and unchecked, convert the 0 to false
        
      
        

          
          
                  # This is ugly.  Anyone have an improvement?
        
      
        

          
          
                  sidebar.fields.each do |field|
        
      
        

          
          
                    sb_attribs[field.key] = field.canonicalize(sb_attribs[field.key])
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          
          
                  sidebar.update_attributes(:config => sb_attribs,
        
      
        

          
          
                                            :active_position => position)
        
      
        

          
          
                  position += 1
        
      
        

          
          
                end
        
      
        

          
          
                Sidebar.delete_all('active_position is null')
        
      
        

          
          
              end
        
      
        

          
          
              PageCache.sweep_all
        
      
        

          
          
              index
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            protected
        
      
        

          
          
          
        
      
        

          2
          
            def show_available
        
      
        

          
          
              render :partial => 'availables', :object => available
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def available
        
      
        

          
          
              ::Sidebar.available_sidebars
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def flash_sidebars
        
      
        

          
          
              unless flash[:sidebars]
        
      
        

          
          
                begin
        
      
        

          
          
                  active = Sidebar.find(:all, :order => 'active_position ASC')
        
      
        

          
          
                  flash[:sidebars] = active.map {|sb| sb.id }
        
      
        

          
          
                rescue => e
        
      
        

          
          
                  logger.error e
        
      
        

          
          
                  # Avoiding the view to crash
        
      
        

          
          
                  @active = []
        
      
        

          
          
                  flash[:error] = _("It seems something went wrong. Maybe some of your sidebars are actually missing and you should either reinstall them or remove them manually")
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              flash[:sidebars]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            helper_method :available
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::TagsController < Admin::BaseController
        
      
        

          2
          
            cache_sweeper :blog_sweeper
        
      
        

          
          
          
        
      
        

          2
          
            def index
        
      
        

          
          
              @tags = Tag.order('display_name').page(params[:page]).per(this_blog.admin_display_elements)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def edit
        
      
        

          
          
              @tag = Tag.find(params[:id])
        
      
        

          
          
              @tag.attributes = params[:tag]
        
      
        

          
          
          
        
      
        

          
          
              if request.post?
        
      
        

          
          
                old_name = @tag.name
        
      
        

          
          
          
        
      
        

          
          
                if @tag.save
        
      
        

          
          
                  # Create a redirection to ensure nothing nasty happens in the future
        
      
        

          
          
                  Redirect.create(:from_path => "/tag/#{old_name}", :to_path => @tag.permalink_url(nil, true))
        
      
        

          
          
          
        
      
        

          
          
                  flash[:notice] = _('Tag was successfully updated.')
        
      
        

          
          
                  redirect_to :action => 'index'
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def destroy
        
      
        

          
          
              @record = Tag.find(params[:id])
        
      
        

          
          
              return(render 'admin/shared/destroy') unless request.post?
        
      
        

          
          
          
        
      
        

          
          
              @record.destroy
        
      
        

          
          
              redirect_to :action => 'index'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          class Admin::TextfiltersController < Admin::BaseController
        
      
        

          2
          
            def macro_help
        
      
        

          
          
              @macro = TextFilter.available_filters.find { |filter| filter.short_name == params[:id] }
        
      
        

          
          
              render :text => BlueCloth.new(@macro.help_text).to_html
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end